En omfattande guide till att slÄ samman och sammanfoga DataFrames i Python Pandas. TÀcker strategier som inner-, outer-, left- och right joins med praktiska exempel.
Python Pandas Merging: BemÀstra strategier för att sammanfoga DataFrames för dataanalys
Datamanipulering Àr en avgörande aspekt av dataanalys, och Pandas-biblioteket i Python tillhandahÄller kraftfulla verktyg för detta ÀndamÄl. Bland dessa verktyg Àr att slÄ samman och sammanfoga DataFrames vÀsentliga operationer för att kombinera dataset baserat pÄ gemensamma kolumner eller index. Den hÀr omfattande guiden utforskar olika strategier för DataFrame-sammanfogning i Pandas och utrustar dig med kunskapen för att effektivt kombinera och analysera data frÄn olika kÀllor.
FörstÄelse för DataFrame Merging och Joining
Att slÄ samman och sammanfoga DataFrames innebÀr att kombinera tvÄ eller flera DataFrames till en enda DataFrame baserat pÄ en delad kolumn eller ett delat index. Den primÀra skillnaden mellan `merge` och `join` Àr att `merge` Àr en funktion i Pandas-biblioteket och vanligtvis sammanfogar DataFrames baserat pÄ kolumner, medan `join` Àr en DataFrame-metod som frÀmst sammanfogar DataFrames baserat pÄ index, Àven om den ocksÄ kan anvÀndas med kolumner.
Nyckelbegrepp
- DataFrames: TvÄdimensionella mÀrkta datastrukturer med kolumner av potentiellt olika typer.
- Gemensamma kolumner/index: Kolumner eller index som delar samma namn och datatyp över DataFrames och som tjÀnar som grund för sammanslagning/sammanfogning.
- Join-typer: Olika strategier för att hantera oöverensstÀmmande rader under sammanslagnings-/sammanfogningsprocessen, inklusive inner, outer, left och right joins.
DataFrame Merging med `pd.merge()`
Funktionen `pd.merge()` Àr det primÀra verktyget för att slÄ samman DataFrames baserat pÄ kolumner. Den erbjuder ett flexibelt sÀtt att kombinera data baserat pÄ en eller flera gemensamma kolumner.
Syntax
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
Parametrar
- left: VÀnster DataFrame som ska slÄs samman.
- right: Höger DataFrame som ska slÄs samman.
- how: Typ av sammanslagning som ska utföras ('inner', 'outer', 'left', 'right'). Standard Àr 'inner'.
- on: Namnet pÄ kolumnerna som ska sammanfogas. Dessa mÄste finnas i bÄda DataFrames.
- left_on: Namnet pÄ kolumnerna i vÀnster DataFrame som ska anvÀndas som sammanfogningsnycklar.
- right_on: Namnet pÄ kolumnerna i höger DataFrame som ska anvÀndas som sammanfogningsnycklar.
- left_index: Om True, anvÀnd indexet frÄn vÀnster DataFrame som sammanfogningsnyckel(ar).
- right_index: Om True, anvÀnd indexet frÄn höger DataFrame som sammanfogningsnyckel(ar).
- sort: Sortera resultat-DataFrame lexikografiskt efter sammanfogningsnycklarna. Standard Àr False.
- suffixes: En tuple med strÀngsuffix som ska tillÀmpas pÄ överlappande kolumnnamn. Standard Àr ('_x', '_y').
- copy: Om False, undvik att kopiera data till den nya DataFrame dÀr det Àr möjligt. Standard Àr True.
- indicator: Om True, lÀgger till en kolumn som heter '_merge' som indikerar kÀllan till varje rad.
- validate: Kontrollerar om sammanslagningen Àr av specificerad typ. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
Join-typer förklarade
Parametern `how` i `pd.merge()` bestÀmmer typen av sammanfogning som utförs. De olika join-typerna hanterar oöverensstÀmmande rader pÄ olika sÀtt.
Inner Join
En inner join returnerar endast de rader som har matchande vÀrden i bÄda DataFrames baserat pÄ sammanfogningsnycklarna. Rader med oöverensstÀmmande vÀrden exkluderas frÄn resultatet.
Exempel:
Betrakta tvÄ DataFrames:
import pandas as pd
# DataFrame 1: KundbestÀllningar
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Kundinformation
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
I det hÀr exemplet kombinerar inner join `df_orders` och `df_customers` DataFrames baserat pÄ kolumnen `customer_id`. Endast kunder som har gjort bestÀllningar inkluderas i resultatet. Kund 'David' (customer_id 106) exkluderas eftersom han inte har nÄgra bestÀllningar.
Outer Join (Full Outer Join)
En outer join returnerar alla rader frÄn bÄda DataFrames, inklusive oöverensstÀmmande rader. Om en rad inte har nÄgon matchning i den andra DataFrame, kommer motsvarande kolumner att innehÄlla `NaN` (Not a Number) vÀrden.
Exempel:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
Output:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
Outer join inkluderar alla kunder och alla bestÀllningar. Kunder 104 och 105 har bestÀllningar men ingen kundinformation, och kund 106 har kundinformation men inga bestÀllningar. De saknade vÀrdena representeras som `NaN`.
Left Join
En left join returnerar alla rader frÄn den vÀnstra DataFrame och de matchande raderna frÄn den högra DataFrame. Om en rad i den vÀnstra DataFrame inte har nÄgon matchning i den högra DataFrame, kommer motsvarande kolumner frÄn den högra DataFrame att innehÄlla `NaN` vÀrden.
Exempel:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
Left join inkluderar alla bestÀllningar frÄn `df_orders`. Kunder 104 och 105 har bestÀllningar men ingen kundinformation, sÄ kolumnerna `customer_name` och `country` Àr `NaN` för de bestÀllningarna.
Right Join
En right join returnerar alla rader frÄn den högra DataFrame och de matchande raderna frÄn den vÀnstra DataFrame. Om en rad i den högra DataFrame inte har nÄgon matchning i den vÀnstra DataFrame, kommer motsvarande kolumner frÄn den vÀnstra DataFrame att innehÄlla `NaN` vÀrden.
Exempel:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
Output:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
Right join inkluderar alla kunder frÄn `df_customers`. Kund 106 har kundinformation men inga bestÀllningar, sÄ kolumnerna `order_id`, `product_id` och `quantity` Àr `NaN` för den kunden.
DataFrame Joining med `df.join()`
Metoden `df.join()` anvÀnds frÀmst för att sammanfoga DataFrames baserat pÄ deras index. Den kan ocksÄ anvÀndas för att sammanfoga baserat pÄ kolumner, men det Àr vanligtvis bekvÀmare att anvÀnda `pd.merge()` för kolumnbaserade sammanfogningar.
Syntax
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
Parametrar
- other: Den andra DataFrame som ska sammanfogas.
- on: Kolumnnamn att sammanfoga pÄ. MÄste anges om indexet inte anvÀnds som sammanfogningsnyckel.
- how: Hur operationen av vÀnster och höger mÀngd ska hanteras. Standard Àr 'left'.
- lsuffix: Suffix att anvÀnda frÄn vÀnster DataFrame för att ÄsidosÀtta överlappande kolumnnamn.
- rsuffix: Suffix att anvÀnda frÄn höger DataFrame för att ÄsidosÀtta överlappande kolumnnamn.
- sort: Sortera resultat-DataFrame lexikografiskt efter sammanfogningsnycklarna. Standard Àr False.
Sammanfogning pÄ Index
Vid sammanfogning pÄ index anvÀnds inte parametern `on`.
Exempel:
# DataFrame 1: KundbestÀllningar med kund-ID som index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Kundinformation med kund-ID som index
df_customers_index = df_customers.set_index('customer_id')
# Join pÄ Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
Output:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
I det hÀr exemplet anvÀnds metoden `join()` för att utföra en left join pÄ indexet (`customer_id`). Resultatet liknar left join med `pd.merge()`, men sammanfogningen baseras pÄ indexet snarare Àn en kolumn.
Sammanfogning pÄ Kolumn
För att sammanfoga pÄ en kolumn med `df.join()`, mÄste du ange parametern `on`.
Exempel:
# Sammanfogning pÄ en kolumn
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
Detta exempel visar sammanfogning av `df_orders` med `df_customers` med hjÀlp av kolumnen `customer_id`. Notera att `customer_id` Àr satt som index i `df_customers` innan sammanfogningen utförs.
Hantering av överlappande kolumner
Vid sammanslagning eller sammanfogning av DataFrames Àr det vanligt att stöta pÄ överlappande kolumnnamn (kolumner med samma namn i bÄda DataFrames). Pandas tillhandahÄller parametern `suffixes` i `pd.merge()` och parametrarna `lsuffix` och `rsuffix` i `df.join()` för att hantera dessa situationer.
AnvÀnda `suffixes` i `pd.merge()`
Parametern `suffixes` lÄter dig ange suffix som lÀggs till de överlappande kolumnnamnen för att skilja dem Ät.
Exempel:
# DataFrame 1: Produktinformation
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Produkt A', 'Produkt B', 'Produkt C'],
'price': [10, 20, 15]
})
# DataFrame 2: Produktinformation (med potentiellt uppdaterade priser)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Produkt A', 'Produkt B', 'Produkt D'],
'price': [12, 18, 25]
})
# Merge med suffix
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
Output:
product_id product_name_old price_old product_name_new price_new
0 1 Produkt A 10 Produkt A 12
1 2 Produkt B 20 Produkt B 18
I det hÀr exemplet finns kolumnerna `product_name` och `price` i bÄda DataFrames. Parametern `suffixes` lÀgger till suffixen `_old` respektive `_new` för att skilja kolumnerna frÄn den vÀnstra respektive högra DataFrame.
AnvÀnda `lsuffix` och `rsuffix` i `df.join()`
Parametrarna `lsuffix` och `rsuffix` tillhandahÄller liknande funktionalitet för `df.join()`. `lsuffix` lÀgger till vÀnster DataFrames överlappande kolumner, och `rsuffix` till höger DataFrames.
Exempel:
# Join med lsuffix och rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
Output:
product_name_old price_old product_name_new price_new
product_id
1 Produkt A 10.0 Produkt A 12.0
2 Produkt B 20.0 Produkt B 18.0
3 Produkt C 15.0 NaN NaN
4 NaN NaN Produkt D 25.0
Praktiska Exempel och AnvÀndningsfall
Att slÄ samman och sammanfoga DataFrames anvÀnds brett i olika dataanalysscenarier. HÀr Àr nÄgra praktiska exempel:
Kombinera FörsÀljningsdata med Produktinformation
Ett vanligt anvÀndningsfall Àr att kombinera försÀljningsdata med produktinformation. Anta att du har en DataFrame som innehÄller försÀljningstransaktioner och en annan DataFrame som innehÄller produktinformation. Du kan slÄ samman dessa DataFrames för att berika försÀljningsdata med produktinformation.
Exempel:
# FörsÀljningstransaktionsdata
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Produktinformation Data
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mus', 'Tangentbord', 'SkÀrm'],
'category': ['Elektronik', 'Elektronik', 'Elektronik', 'Elektronik'],
'price': [1200, 25, 75, 300]
})
# SlÄ samman FörsÀljningsdata med Produktinformation
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
Output:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Elektronik 1200
1 2 102 1 2023-02-20 Mus Elektronik 25
2 3 103 3 2023-03-10 Tangentbord Elektronik 75
3 4 101 1 2023-04-05 Laptop Elektronik 1200
4 5 104 2 2023-05-01 SkÀrm Elektronik 300
Den resulterande DataFrame `df_sales_enriched` innehÄller försÀljningstransaktionerna tillsammans med motsvarande produktinformation, vilket möjliggör en mer detaljerad analys av försÀljningstrender och produktprestanda.
Kombinera Kunddata med Demografisk Information
Ett annat vanligt anvÀndningsfall Àr att kombinera kunddata med demografisk information. Detta möjliggör analys av kundbeteende baserat pÄ demografiska faktorer.
Exempel:
# Kunddata
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Demografisk information Data
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# SlÄ samman Kunddata med Demografisk Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
Output:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
Den resulterande DataFrame `df_customer_demographics` innehÄller kunddata tillsammans med den demografiska informationen för deras respektive stÀder, vilket möjliggör analys av kundbeteende baserat pÄ stadsdemografi.
Analysera Global Försörjningskedjedata
Pandas merging Àr vÀrdefullt för att analysera global försörjningskedjedata, dÀr information ofta Àr spridd över flera tabeller. Till exempel kan lÀnkning av leverantörsdata, fraktinformation och försÀljningssiffror avslöja flaskhalsar och optimera logistiken.
Exempel:
# Leverantörsdata
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Tyskland', 'Kina']
})
# Fraktdata
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Kanada', 'Australien', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# SlÄ samman Leverantörs- och Fraktdata
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
Output:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Kanada 2023-02-15 EuroParts Tyskland
2 103 3 Australien 2023-03-20 AsiaSource Kina
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
Avancerade Merging-tekniker
Sammanslagning pÄ Flera Kolumner
Du kan slÄ samman DataFrames baserat pÄ flera kolumner genom att skicka en lista med kolumnnamn till parametern `on`.
Exempel:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# SlÄ samman pÄ flera kolumner
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
Output:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
Sammanslagning med olika kolumnnamn
Om sammanfogningskolumnerna har olika namn i de tvÄ DataFrames kan du anvÀnda parametrarna `left_on` och `right_on` för att ange kolumnnamnen som ska anvÀndas för sammanslagning.
Exempel:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Produkt A', 'Produkt B', 'Produkt C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# SlÄ samman med olika kolumnnamn
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
Output:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
AnvÀnda `indicator` för Merge-analys
Parametern `indicator` i `pd.merge()` lÀgger till en kolumn som heter `_merge` i den resulterande DataFrame, vilket indikerar kÀllan till varje rad. Detta Àr anvÀndbart för att förstÄ vilka rader som matchades och vilka som inte gjorde det.
Exempel:
# SlÄ samman med indikator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
Output:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
Kolumnen `_merge` indikerar om raden Àr frÄn bÄda DataFrames (`both`), endast frÄn den vÀnstra DataFrame (`left_only`) eller endast frÄn den högra DataFrame (`right_only`).
Validera Merge-typer
Parametern `validate` sÀkerstÀller att sammanslagningsoperationen överensstÀmmer med förvÀntade relationstyper mellan DataFrames (t.ex. 'one_to_one', 'one_to_many'). Detta hjÀlper till att förhindra datainkonsekvenser och fel.
Exempel:
# Exempel med one-to-one-validering
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Utför en one-to-one merge med validering
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
Om sammanslagningen bryter mot den specificerade valideringen (t.ex. en many-to-one-relation nÀr 'one_to_one' anges) kommer ett `MergeError` att utlösas, vilket varnar dig om potentiella dataintegritetsproblem.
PrestandaövervÀganden
Att slÄ samman och sammanfoga DataFrames kan vara berÀkningsmÀssigt dyrt, sÀrskilt för stora dataset. HÀr Àr nÄgra tips för att förbÀttra prestandan:
- AnvÀnd lÀmplig join-typ: Att vÀlja rÀtt join-typ kan avsevÀrt pÄverka prestandan. Om du till exempel bara behöver matchande rader, anvÀnd en inner join.
- Indexera join-kolumnerna: Att indexera join-kolumnerna kan snabba upp sammanslagningsprocessen.
- AnvÀnd lÀmpliga datatyper: Se till att join-kolumnerna har kompatibla datatyper.
- Undvik onödiga kopior: StÀll in `copy=False` i `pd.merge()` och `df.join()` för att undvika att skapa onödiga kopior av datan.
Slutsats
Att slÄ samman och sammanfoga DataFrames Àr grundlÀggande operationer inom dataanalys. Genom att förstÄ de olika join-typerna och teknikerna kan du effektivt kombinera och analysera data frÄn olika kÀllor, lÄsa upp vÀrdefulla insikter och driva informerade beslut. FrÄn att kombinera försÀljningsdata med produktinformation till att analysera globala försörjningskedjor, kommer att bemÀstra dessa tekniker att ge dig möjlighet att hantera komplexa datamanipuleringsuppgifter med förtroende. Kom ihÄg att beakta prestandaimplikationer nÀr du arbetar med stora dataset och utnyttja avancerade funktioner som parametrarna `indicator` och `validate` för mer robust och insiktsfull analys.